#include<iostream>
using namespace std;

typedef long long ll;
#if 0
// 同余：a - b = q*m，q为整数，则 a ≡ b (mod m)
// 若a≡b(% p)，则对于任意的c，都有(a + c) ≡ (b + c)(% p)；
// 若a≡b(% p)，则对于任意的c，都有(a *c) ≡ (b *c)(% p)；
// 若a≡b(% p)，c≡d(% p)，则(a + c) ≡ (b + d)(% p)，(a - c) ≡ (b - d)(% p)，(a *c) ≡ (b *d)(% p)；

/******************* 欧拉函数 ****************/
// 互质：公约数只有1的两个整数
// 1 ~ n 中与n互质的数的个数被称为欧拉函数
// 算数基本定理：n = p1^k1 * p2^k2 * ... * pi^ki
// 欧拉函数：phi(n) = n * (p1 - 1)/p1 * (p2 - 1)/p2 * ... (pi - 1)/pi
/* 找到1~N中与N互质的数的个数，正难则反，只需找到1~N中与N不互质的数的个数即可，即去掉与N又相同质因子的数
用到容斥原理：
= N - N/p1 - N/p2 - ... - N/pi
    + N/(p1*p2) + N/(p1*p3) + ...
    - N/(p1*p2*p3) - N/(p1*p2*p4) - ...
    ...
*/
// 欧拉定理：若a与n互质，则a^phi(n) ≡ 1 (mod n)
// 1、求一个数的欧拉函数

// int phi(int n)
// {
//     int ans = n;
//     for(int i = 2; i <= n / i; ++i)
//     {
//         if(n % i == 0)
//         {
//             ans = ans / i * (i - 1); // ans *= (i - 1)/i; 考虑到除法向0取整
//             while(n % i == 0) n /= i;
//         }
//     }
//     if(n > 1)
//         ans = ans / n * (n - 1);
//     return ans;
// }

/********* 欧拉函数应用 https://www.lanqiao.cn/problems/20086/learning/?contest_id=228 ******/
// #include <iostream>
// using namespace std;

// typedef long long ll;
// // 求n的欧拉函数
// int main()
// {
//     ll n;
//     cin >> n;
//     ll ret = n;
//     for(ll i = 2; i <= n / i; ++i)
//     {
//         if(n % i == 0)
//         {
//             ret = ret / i * (i - 1);
//             while(n % i == 0)
//                 n /= i;
//         }
//     }
//     if(n > 1)
//         ret = ret / n * (n - 1);
//     cout << ret;
//     return 0;
// }

// 2、求1 ~ n所有数的欧拉函数 -线性筛
const int N = 1e6 + 10;
bool st[N];
int phi[N], prime[N], idx;

void phi_range(int n)
{
    phi[1] = 1; //根据定义
    for(int i = 2; i <= n; ++i)
    {
        if(!st[i])
        {
            prime[idx++] = i;
            phi[i] = i - 1;
        }
        for(int j = 0; prime[j] <= n / i; ++j)
        {
            st[prime[j] * i] = true;
            // pj 是 i 的最小质因子，pj * i 与 i 的所有质因子相同
            if(i % prime[j] == 0)
            {
                phi[prime[j] * i] = prime[j] * phi[i];
                break;
            }
            // pj 不是 i的最小质因子，令 i 的质因子为 p1、p2、...pk
            // phi(pj*i) = pj * i * (p1-1)/p1 * ... * (pk-1)pk * (pj-1)/pj
            //           = pj * (pj-1)/pj * phi(i) = phi(i) * (pj - 1)
            else
            {
                phi[prime[j] * i] = (prime[j] - 1) * phi[i];
            }
        }
    }
}


/******************* 快速幂 *****************/
// 1、二进制思想
// 求a^b, 将b看成二进制, 预处理出来 a^1, a^2, a^4, a^8 ...
// a^b 一定可以由预处理出来的数相乘得到
int qmi(int a, int b, int p)
{
    int ret = 1;
    while (b)
    {
        if (b & 1) ret = (ll)ret * a % p;
        b >>= 1;
        a = (ll)a * a % p;
    }
    // // 或者这样写：
    // for (; b; b >>= 1, a = (long long)a * a % p)
    //     if (b & 1) ret = (long long)ret * a % p;
    return ret;
}

// 2、递归版
// b是偶数：a^b = (a ^ b/2) * (a ^ b/2)
// b是奇数：a^b = (a ^ b/2) * (a ^ b/2) * a
int my_pow(int a, int b, int p)
{
    if(b == 0)  return 1;
    int tmp = my_pow(a, b / 2, p);
    if(b % 2 == 0)  
        return (ll)tmp * tmp % p;
    else    
        return ((ll)tmp * tmp % p) * a % p;
}

// 3、快速幂求逆元
// b | a, b与m互质, 若存在x 使得 a / b ≡ a * x  (mod m) ---> 则x就是 b模m的乘法逆元, 记为b^-1 (mod m)
// a / b ≡ a * b^-1 (mod m)
// a ≡ a * b*b^-1 (mod m)
// b*b^-1 ≡ 1 (mod m)
// 由欧拉定理 a^phi(n) ≡ 1 (mod n)
// 可知：b*b^-1 ≡ 1 ≡ b^phi(m) (mod m)  注：gcd(b,m) == 1，时，b才有mod m 的逆元
// b^-1 ≡ b^(phi(m)-1) (mod m) ==>
// b^-1 = b^(phi(m) - 1) % m

void test()
{   //a模p的乘法逆元, 保证p是质数
    int n, a, p;
    scanf("%d", &n);
    while(n--)
    {
        scanf("%d%d", &a, &p);
        if(a % p == 0) puts("impossible");
        else printf("%d\n", qmi(a, p - 2, p));
    }
}

/************* 扩展欧几里得算法 **************/
// 裴蜀定理：
//  对于任意正整数a、b，一定存在非0整数x、y，使得
//           ax + by = (a, b)
//  令 d = ax + by，则d一定是a跟b的最大公约数的倍数。a和b能凑出来的最小正整数就是最大公约数
// ax1 + by1 = (a, b)
// (b, a%b) = bx2 + (a%b)y2
//          = bx2 + (a - a/b)y2
//          = ay2 + b(x2 - a/b * y2)
// x1 = y2, y1 = x2 - a/b * y2;

int exgcd(int a, int b, int& x, int& y)
{
    if(b == 0)
    {
        x = 1, y = 0;
        return a;
    }
    int xx, yy;
    int d = exgcd(b, a % b, xx, yy);
    x = yy, y = xx - a / b * yy;
    return d;
}

// 扩展欧几里得算法求逆元
// a*x ≡ 1 (mod p)  注：a与p互质才又逆元
// a*x - k*p = 1, 由于(a, p) = 1
// a*x - k*p = (a, p), 可用扩展欧几里得求x
// 由于 a*x ≡ 1 (mod p) ==> a * (x % p) ≡ 1 (mod p)
int inv(int a, int p)
{
    int x, y;
    int d = exgcd(a, p, x, y);
    if(d == 1)
        return ((ll)x % p + p) % p; //扩展都几里德求出来的x可能为负数
    return -1;
}

// 线性同余方程   https://www.acwing.com/problem/content/description/880/
// 求x，使得 a*x ≡ b (mod p)
// ax - b = kp
// ax - kp = b 可以看出 b 一定是gcd(a,p)的倍数，即 gcd(a,p) | b。 如果b不是(a,p)的倍数，则无解
// 令y = -k
// ax + py = (a, p) * b/(a, p)
// ax1 + py1 = (a, p) 根据扩展欧几里得可以求出x1
// x = x1 * b/(a, p)

// int main()
// {
//     int n, a, b, m;
//     scanf("%d", &n);
//     while(n--)
//     {
//         scanf("%d %d %d", &a, &b, &m);
//         int x, y;
//         int d = exgcd(a, m, x, y);
//         if(b % d != 0) puts("impossible");
//         else
//             printf("%d\n", (ll)x * b / d % m);
//         // a*x ≡ b (mod m) ==> a*(x % m) ≡ b (mod m)
//     }
//     return 0;
// }

/************** 中国剩余定理 ****************/

// int main()
// {
//     return 0;
// }


/******************** 高斯消元 *******************/
#include <iostream>
using namespace std;
#include <cstring>
#include<cmath>

const int N = 110;
double g[N][N], x[N]; // g系数矩阵；x表示未知数的解，从0开始
int n;
const double MIN = 0.00000001; // 用于判断是否为0

// 判断是否为0
bool equal(double &d)
{
    return abs(d) < MIN;
}

// 第i行 *k 加到第j行
void add(int i, int j, double k)
{
    if (equal(k))
        return;
    for (int a = 0; a < n + 1; ++a)
        g[j][a] += k * g[i][a];
}

// 第i行 *k
void mul(int i, double k)
{
    for (int j = 0; j < n + 1; ++j)
        g[i][j] *= k;
}

// 交换i、j行
void swap(int i, int j)
{
    double tmp[n + 1];
    memcpy(tmp, g[i], sizeof tmp);
    memcpy(g[i], g[j], sizeof tmp);
    memcpy(g[j], tmp, sizeof tmp);
}

// 计算，在调用函数之前，要保证g[i][j]为1
void calculate(int i, int j)
{
    // 用第i行去消掉 i+1 ~ n行
    for (int cur = i + 1; cur < n; ++cur)
        add(i, cur, -g[cur][j]);
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n + 1; ++j)
            scanf("%lf", &g[i][j]);

    // i:行，j:列
    int i = 0, j = 0;

    // 条件可以只写 j < n，因为i往后时j也往后，而j往后是i可能不动
    while (i < n && j < n)
    {
        // 从第i行第j列往下找非零值，找到了就计算，找不到++j //err 精度不够
        /*
        bool flag = true;
        for (int k = i; k < n; ++k)
        {
            if (!equal(g[k][j]))
            {
                flag = false;
                if (k != i)
                    add(i, k, 1.0 / g[k][j]);
                else
                    mul(i, 1.0 / g[i][j]);
                break;
            }
        }
        if (flag == false)
        {
            calculate(i, j);
            ++i, ++j;
        }
        else
            ++j;
        */
        // 要找绝对值最大的，把它变为1
        int t = i;
        for (int k = i; k < n; ++k)
        {
            // 补：返回值 abs：int。
            // fabs: double。  fabsf: float。  fabsl: long double
            if (fabs(g[k][j]) > fabs(g[t][j]))
                t = k;
        }
        // 没找到非零值，去下一列找
        if (equal(g[t][j]))
            ++j;

        // 找到了，把他变为1，然后跟首行交换，计算
        else
        {
            mul(t, 1.0 / g[t][j]);
            swap(t, i);
            calculate(i, j);
            ++i, ++j;
        }
    }
    // 行没走完，说明不是满秩，可能无解 / 无穷多解
    if (i != n)
    {
        // 停在了第i行，说明从[1, n-1]行x系数都为零，判断右侧常数是否非零
        for (int k = n - 1; k >= i; --k)
            if (!equal(g[k][n]))
            {
                puts("No solution");
                return 0;
            }
        puts("Infinite group solutions");
    }

    // 行走完了，列也必定走完
    else
    {
        // for (int i = n - 1; i >= 0; --i)
        // {
        //     double ret = g[i][n];
        //     for (int j = i + 1; j < n; ++j)
        //     {
        //         ret -= g[i][j] * x[j];
        //     }
        //     x[i] = ret;
        // }
        // for (int i = 0; i < n; ++i)
        //     printf("%.2lf\n", x[i]);

        // // 最后一步计算也可以这样
        for (int j = n - 1; j >= 0; --j)
            for (int cur = j - 1; cur >= 0; --cur) // 行
                add(j, cur, -g[cur][j]);
        
        for (int i = 0; i < n; ++i)
            printf("%.2lf\n", g[i][n]);
    }
    return 0;
}
#endif